package main

import (
	"fmt"
	"strconv"
)

const (
	svα   = 1 << 0 // svα 的值为 1 (2^0)
	svβ   = 1 << 1 // svβ 的值为 2 (2^1)
	svγ   = 1 << 2 // svγ 的值为 4 (2^2)
	svA   = 1 << 5 // svA 的值为 32 (2^5)
	svCLR = 1 << 8 // svCLR 的值为 256 (2^8)

	su2qα   = 1 << 0 // su2qα 的值为 1 (2^0)
	su2qA   = 1 << 3 // su2qA 的值为 8 (2^3)
	su2qS   = 1 << 4 // su2qS 的值为 16 (2^4)
	su2qCLR = 1 << 5 // su2qCLR 的值为 32 (2^5)
	su2sα   = 1 << 1 // su2sα 的值为 2 (2^1)
	su2sA   = 1 << 2 // su2sA 的值为 4 (2^2)
	su2sCLR = 1 << 6 // su2sCLR 的值为 64 (2^6)

	su3α   = 1 << 0 // su3α 的值为 1 (2^0)
	su3β   = 1 << 1 // su3β 的值为 2 (2^1)
	su3γ   = 1 << 2 // su3γ 的值为 4 (2^2)
	su3A   = 1 << 3 // su3A 的值为 8 (2^3)
	su3S   = 1 << 4 // su3S 的值为 16 (2^4)
	su3CLR = 1 << 5 // su3CLR 的值为 32 (2^5)
)

// Lots of state vars and I don't want to worry about name collisions
var divsr struct {
	// 通道：用于接收更新信号或控制指令
	divupdate chan int

	// 通道数组：每个包含8个脉冲通道
	// progin: 输入脉冲通道，可能用于接收输入数据
	// progout: 输出脉冲通道，可能用于发送输出数据
	// ilock: 锁定脉冲通道，可能用于同步或锁定机制
	progin, progout, ilock [8]chan pulse

	// 脉冲通道：用于发送计算结果
	answer chan pulse

	// 整数数组：每个包含8个整数
	// numarg: 数值参数，可能用于存储被除数的参数
	// numcl: 数值清除标志，可能用于清除数值相关的状态
	// denarg: 分母参数，可能用于存储除数的参数
	// dencl: 分母清除标志，可能用于清除分母相关的状态
	// roundoff: 舍入偏移量，可能用于舍入操作
	// places: 小数位数，可能用于指定结果的小数位数
	// ilocksw: 锁定开关状态，可能用于控制锁定机制的状态
	// anssw: 答案开关状态，可能用于控制答案的输出
	numarg, numcl, denarg, dencl, roundoff, places, ilocksw, anssw [8]int

	// 布尔数组：每个包含8个布尔值
	// preff: 预设标志，可能用于标记某些预设条件
	// progff: 程序标志，可能用于标记程序执行的状态
	preff, progff [8]bool

	// 整数：用于表示某些计数器或状态
	// placering: 小数环位置，可能用于跟踪小数位的位置
	// progring: 程序环位置，可能用于跟踪程序执行的位置
	placering, progring int

	// 布尔标志：用于表示各种状态或条件
	divff        bool // 除法标志，可能用于标记正在进行除法操作
	clrff        bool // 清除标志，可能用于标记需要清除某些状态
	ilockff      bool // 锁定标志，可能用于标记锁定机制的状态
	coinff       bool // 控制输入标志，可能用于标记控制输入的状态
	dpγ          bool // 数据处理标志，可能用于标记某种数据处理状态
	nγ           bool // 某种状态标志，具体用途需结合上下文理解
	psrcff       bool // 源标志，可能用于标记源状态
	pringff      bool // 程序环标志，可能用于标记程序环的状态
	denomff      bool // 分母标志，可能用于标记分母的状态
	numrplus     bool // 数值加标志，可能用于标记数值增加的状态
	numrmin      bool // 数值减标志，可能用于标记数值减少的状态
	qα           bool // 某种状态标志，具体用途需结合上下文理解
	sac          bool // 存储累加器标志，可能用于标记存储累加器的状态
	m2, m1       bool // 标志位，可能用于标记某些中间状态
	nac          bool // 数值累加器标志，可能用于标记数值累加器的状态
	da           bool // 数据可用标志，可能用于标记数据是否可用
	nα, dα, dγ   bool // 标志位，具体用途需结合上下文理解
	npγ          bool // 标志位，具体用途需结合上下文理解
	p2, p1       bool // 标志位，可能用于标记某些阶段的状态
	sα           bool // 标志位，具体用途需结合上下文理解
	ds           bool // 数据状态标志，可能用于标记数据的状态
	nβ, dβ       bool // 标志位，具体用途需结合上下文理解

	// 布尔标志：用于表示答案的状态
	ans1, ans2, ans3, ans4 bool

	// 整数：用于表示当前程序、适应性参数等
	// curprog: 当前程序编号，可能用于跟踪当前执行的程序
	// divadap: 除法适应性参数，可能用于调整除法操作的行为
	// sradap: 其他适应性参数，可能用于调整其他操作的行为
	curprog, divadap, sradap int

	// 整数：用于表示某些状态或配置
	// sv: 状态变量，可能用于存储某种状态
	// su2: 状态单元2，可能用于存储另一种状态
	// su3: 状态单元3，可能用于存储第三种状态
	sv, su2, su3 int
}

// 返回 divsr 结构体的状态字符串表示
func divsrstat() string {
	// 初始化状态字符串，包含 placering 和 progring 的值
	s := fmt.Sprintf("%d %d ", divsr.placering, divsr.progring)

	// 遍历 progff 数组，将每个布尔值转换为 "1" 或 "0" 并附加到状态字符串中
	for i := 0; i < 8; i++ {
		if divsr.progff[i] {
			s += "1"
		} else {
			s += "0"
		}
	}

	// 使用 b2is 函数将布尔标志转换为字符串，并附加到状态字符串中
	s += " " + b2is(divsr.divff) + b2is(divsr.clrff) + b2is(divsr.coinff) + b2is(divsr.dpγ) +
		b2is(divsr.nγ) + b2is(divsr.psrcff) + b2is(divsr.pringff) + b2is(divsr.denomff) +
		b2is(divsr.numrplus) + b2is(divsr.numrmin) + b2is(divsr.qα) + b2is(divsr.sac) +
		b2is(divsr.m2) + b2is(divsr.m1) + b2is(divsr.nac) + b2is(divsr.da) + b2is(divsr.nα) +
		b2is(divsr.dα) + b2is(divsr.dγ) + b2is(divsr.npγ) + b2is(divsr.p2) + b2is(divsr.p1) +
		b2is(divsr.sα) + b2is(divsr.ds) + b2is(divsr.nβ) + b2is(divsr.dβ) + b2is(divsr.ans1) +
		b2is(divsr.ans2) + b2is(divsr.ans3) + b2is(divsr.ans4)

	return s
}

// 返回 divsr 结构体的状态字符串表示（更详细的描述）
func divsrstat2() string {
	// 初始化状态字符串，包含 placering 和 progring 的值
	s := fmt.Sprintf("%d %d ", divsr.placering, divsr.progring)

	// 遍历 progff 数组，将每个布尔值转换为 "1" 或 "0" 并附加到状态字符串中
	for i := 0; i < 8; i++ {
		if divsr.progff[i] {
			s += "1"
		} else {
			s += "0"
		}
	}

	// 根据布尔标志的值附加相应的标识符到状态字符串中
	if divsr.divff {
		s += " divff"
	}
	if divsr.clrff {
		s += " clrff"
	}
	if divsr.coinff {
		s += " coinff"
	}
	if divsr.dpγ {
		s += " dpg"
	}
	if divsr.nγ {
		s += " ng"
	}
	if divsr.psrcff {
		s += " psrcff"
	}
	if divsr.pringff {
		s += " pringff"
	}
	if divsr.denomff {
		s += " denomff"
	}
	if divsr.numrplus {
		s += " n+"
	}
	if divsr.numrmin {
		s += " n-"
	}
	if divsr.qα {
		s += " qa"
	}
	if divsr.sac {
		s += " SAC"
	}
	if divsr.m2 {
		s += " -2"
	}
	if divsr.m1 {
		s += " -1"
	}
	if divsr.nac {
		s += " NAC"
	}
	if divsr.da {
		s += " dA"
	}
	if divsr.nα {
		s += " na"
	}
	if divsr.dα {
		s += " da"
	}
	if divsr.dγ {
		s += " dg"
	}
	if divsr.npγ {
		s += " npg"
	}
	if divsr.p2 {
		s += " +2"
	}
	if divsr.p1 {
		s += " +1"
	}
	if divsr.sα {
		s += " sa"
	}
	if divsr.ds {
		s += " dS"
	}
	if divsr.nβ {
		s += " nb"
	}
	if divsr.dβ {
		s += " db"
	}
	if divsr.ans1 {
		s += " A1"
	}
	if divsr.ans2 {
		s += " A2"
	}
	if divsr.ans3 {
		s += " A3"
	}
	if divsr.ans4 {
		s += " A4"
	}

	return s
}

// 重置 divsr 结构体的状态
func divreset() {
	// 遍历并重置所有通道和整数数组
	for i := 0; i < 8; i++ {
		divsr.progin[i] = nil // 清除输入脉冲通道
		divsr.progout[i] = nil // 清除输出脉冲通道
		divsr.ilock[i] = nil // 清除锁定脉冲通道
		divsr.numarg[i] = 0 // 重置数值参数
		divsr.numcl[i] = 0 // 重置数值清除标志
		divsr.denarg[i] = 0 // 重置分母参数
		divsr.dencl[i] = 0 // 重置分母清除标志
		divsr.roundoff[i] = 0 // 重置舍入偏移量
		divsr.places[i] = 0 // 重置小数位数
		divsr.ilocksw[i] = 0 // 重置锁定开关状态
		divsr.anssw[i] = 0 // 重置答案开关状态
		divsr.preff[i] = false // 重置预设标志
		divsr.progff[i] = false // 重置程序标志
	}

	// 清除其他通道和布尔标志
	divsr.answer = nil // 清除答案通道
	divsr.divff = false // 重置除法标志
	divsr.ilockff = false // 重置锁定标志
	divsr.ans1 = false // 重置答案标志1
	divsr.ans2 = false // 重置答案标志2
	divsr.ans3 = false // 重置答案标志3
	divsr.ans4 = false // 重置答案标志4
	divsr.divadap = 0 // 重置除法适应性参数
	divsr.sradap = 0 // 重置其他适应性参数

	// 调用 divclear 函数进行更深层次的清理
	divclear()

	// 发送更新信号到 divupdate 通道
	divsr.divupdate <- 1
}

// 进行更深一层的清理操作
func divclear() {
	// 调用 divintclear 函数清理内部状态
	divintclear()

	// 重置状态变量
	divsr.sv = 0 // 重置状态变量 sv
	divsr.su2 = 0 // 重置状态单元 su2
	divsr.su3 = 0 // 重置状态单元 su3
}

// 清理 divsr 内部状态
func divintclear() {
	// 重置各种布尔标志和计数器
	divsr.progring = 0 // 重置程序环位置
	divsr.placering = 0 // 重置小数环位置
	divsr.numrplus = true // 设置数值加标志为 true
	divsr.numrmin = false // 设置数值减标志为 false
	divsr.denomff = false // 重置分母标志
	divsr.psrcff = false // 重置源标志
	divsr.pringff = false // 重置程序环标志
	divsr.curprog = -1 // 重置当前程序编号
	divsr.coinff = false // 重置控制输入标志
	divsr.clrff = false // 重置清除标志
	divsr.dpγ = false // 重置数据处理标志
	divsr.nγ = false // 重置某种状态标志
	divsr.qα = false // 重置某种状态标志
	divsr.sac = false // 重置存储累加器标志
	divsr.m2 = false // 重置中间状态标志
	divsr.m1 = false // 重置中间状态标志
	divsr.nac = false // 重置数值累加器标志
	divsr.da = false // 重置数据可用标志
	divsr.nα = false // 重置某种状态标志
	divsr.dα = false // 重置某种状态标志
	divsr.dγ = false // 重置某种状态标志
	divsr.npγ = false // 重置某种状态标志
	divsr.p2 = false // 重置某种阶段状态标志
	divsr.p1 = false // 重置某种阶段状态标志
	divsr.sα = false // 重置某种状态标志
	divsr.ds = false // 重置数据状态标志
	divsr.nβ = false // 重置某种状态标志
	divsr.dβ = false // 重置某种状态标志
}

// 插入插头（连接通道）
func divsrplug(jack string, ch chan pulse) {
	var prog int
	var ilk rune

	// 如果插头名称是 "ans" 或 "ANS"，则设置 answer 通道
	if jack == "ans" || jack == "ANS" {
		divsr.answer = ch
	} else {
		// 否则解析插头名称，确定程序编号和类型
		fmt.Sscanf(jack, "%d%c", &prog, &ilk)
		switch ilk {
		case 'i':
			divsr.progin[prog-1] = ch // 设置输入脉冲通道
		case 'o':
			divsr.progout[prog-1] = ch // 设置输出脉冲通道
		case 'l':
			divsr.ilock[prog-1] = ch // 设置锁定脉冲通道
		}
	}

	// 发送更新信号到 divupdate 通道
	divsr.divupdate <- 1
}

// 控制 divsr 的状态
func divsrctl(ch chan [2]string) {
	for {
		ctl := <-ch // 从控制通道接收命令
		sw, _ := strconv.Atoi(ctl[0][2:]) // 解析命令中的数字部分
		switch ctl[0][:2] { // 根据命令前缀执行相应的操作
		case "da":
			divsr.divadap = int(ctl[1][0] - 'A') // 设置除法适应性参数
		case "ra":
			divsr.sradap = int(ctl[1][0] - 'A') // 设置其他适应性参数
		case "nr":
			// 根据命令设置数值参数
			switch ctl[1] {
			case "α", "a", "alpha":
				divsr.numarg[sw-1] = 0
			case "β", "b", "beta":
				divsr.numarg[sw-1] = 1
			case "0":
				divsr.numarg[sw-1] = 2
			}
		case "nc":
			// 根据命令设置数值清除标志
			if ctl[1] == "C" || ctl[1] == "c" {
				divsr.numcl[sw-1] = 1
			} else {
				divsr.numcl[sw-1] = 0
			}
		case "dr":
			// 根据命令设置分母参数
			switch ctl[1] {
			case "α", "a", "alpha":
				divsr.denarg[sw-1] = 0
			case "β", "b", "beta":
				divsr.denarg[sw-1] = 1
			case "0":
				divsr.denarg[sw-1] = 2
			}
		case "dc":
			// 根据命令设置分母清除标志
			if ctl[1] == "C" || ctl[1] == "c" {
				divsr.dencl[sw-1] = 1
			} else {
				divsr.dencl[sw-1] = 0
			}
		case "pl":
			// 根据命令设置小数位数
			offset := 5
			pl, _ := strconv.Atoi(ctl[1][1:])
			if ctl[1][0] == 'D' {
				offset = 0
			}
			if pl == 4 {
				divsr.places[sw-1] = 0 + offset
			} else {
				divsr.places[sw-1] = pl - 6 + offset
			}
		case "ro":
			// 根据命令设置舍入偏移量
			if ctl[1] == "RO" || ctl[1] == "ro" {
				divsr.roundoff[sw-1] = 1
			} else {
				divsr.roundoff[sw-1] = 0
			}
		case "an":
			// 根据命令设置答案开关状态
			if ctl[1] == "OFF" || ctl[1] == "off" {
				divsr.anssw[sw-1] = 4
			} else {
				val, _ := strconv.Atoi(ctl[1])
				divsr.anssw[sw-1] = val - 1
			}
		case "il":
			// 根据命令设置锁定开关状态
			if ctl[1] == "I" || ctl[1] == "i" {
				divsr.ilocksw[sw-1] = 1
			} else {
				divsr.ilocksw[sw-1] = 0
			}
		default:
			// 输出无效命令信息
			fmt.Printf("Invalid divider switch %s\n", ctl[0])
		}
	}
}

// 设置 divsr 的参数状态
func divargs(prog int) {
	// 设置预设标志为 true
	divsr.preff[prog] = true

	// 根据 places 数组的值设置 divff 标志
	if divsr.places[prog] < 5 {
		divsr.divff = true
	} else {
		divsr.divff = false
	}

	// 根据 numarg 数组的值设置相应的布尔标志和状态变量
	switch divsr.numarg[prog] {
	case 0:
		divsr.nα = true // 设置数值加标志 nα
		divsr.sv |= svα // 更新状态变量 sv
	case 1:
		divsr.nβ = true // 设置数值减标志 nβ
		divsr.sv |= svβ // 更新状态变量 sv
	}

	// 根据 denarg 数组的值设置相应的布尔标志和状态变量
	switch divsr.denarg[prog] {
	case 0:
		divsr.dα = true // 设置分母加标志 dα
		divsr.su3 |= su3α // 更新状态单元 su3
	case 1:
		divsr.dβ = true // 设置分母减标志 dβ
		divsr.su3 |= su3β // 更新状态单元 su3
	}
}

// 执行 P 操作
func doP() {
	// 设置数值 γ 标志 nγ 和状态变量 sv
	divsr.nγ = true
	divsr.sv |= svγ

	// 根据 samesign 函数的结果设置数据状态标志 ds 或 da
	if samesign() {
		divsr.ds = true // 设置数据状态标志 ds
		divsr.su3 |= su3S // 更新状态单元 su3
	} else {
		divsr.da = true // 设置数据可用标志 da
		divsr.su3 |= su3A // 更新状态单元 su3
	}
}

// 执行 S 操作
func doS() {
	// 设置状态标志 sα 和更新状态单元 su2
	divsr.sα = true
	divsr.su2 |= su2sα

	// 设置数值累加器标志 nac 和更新状态变量 sv
	divsr.nac = true
	divsr.sv |= svA | svCLR

	// 如果 divff 标志为 false，根据 samesign 函数的结果设置 m1 或 p1 标志
	if !divsr.divff {
		if samesign() {
			divsr.m1 = true // 设置中间状态标志 m1
		} else {
			divsr.p1 = true // 设置中间状态标志 p1
		}
		divsr.dpγ = true // 设置数据处理标志 dpγ
		divsr.su3 |= su3γ // 更新状态单元 su3
	}

	// 计算当前程序的小数位数并调整
	p := divsr.places[divsr.curprog] % 5
	if p == 0 {
		p = 4
	} else {
		p += 6
	}

	// 如果 placering 等于特定值，设置 psrcff 标志
	if divsr.placering == p-2 { // Gate E6
		divsr.psrcff = true // 设置源标志 psrcff
	}
}

// 判断符号是否相同
func samesign() bool {
	// 返回 denomff 和 numrmin 同时为 true 或者 denomff 和 numrplus 同时为 false
	return divsr.denomff && divsr.numrmin || !divsr.denomff && divsr.numrplus
}

// 判断是否溢出
func overflow() bool {
	// 获取累加器状态，并根据第一个字符判断是否溢出
	s := accstat(2)
	return (s[0] == 'P' && divsr.numrmin) || (s[0] == 'M' && divsr.numrplus)
}

// 执行 GP 操作，并通过响应通道返回结果
func doGP(resp chan int) {
	// Gate E50: 检查控制输入标志 coinff 和锁定开关状态 ilocksw
	if divsr.coinff { 
		if divsr.ilocksw[divsr.curprog] == 0 || divsr.ilockff {
			divsr.coinff = false // 清除控制输入标志
			divsr.clrff = true   // 设置清除标志
			return
		}
	} else if divsr.clrff {
		// 如果 clrff 标志为 true，重置程序标志并进行握手
		divsr.progff[divsr.curprog] = false
		handshake(1, divsr.progout[divsr.curprog], resp)
		if divsr.ilocksw[divsr.curprog] == 1 {
			divsr.ilockff = false // 清除锁定标志
		}

		// 实现 PX-4-114 适配器逻辑
		switch divsr.anssw[divsr.curprog] {
		case 0:
			divsr.ans1 = true
			divsr.su2 |= su2qA
			if divsr.divadap == 2 {
				divsr.su2 |= su2qCLR
			}
		case 1:
			divsr.ans2 = true
			switch divsr.divadap {
			case 0:
				divsr.su2 |= su2qA | su2qCLR
			case 1:
				divsr.su2 |= su2qS
			case 2:
				divsr.su2 |= su2qS | su2qCLR
			}
		case 2:
			divsr.ans3 = true
			divsr.su3 |= su3A
			if divsr.sradap == 2 {
				divsr.su3 |= su3CLR
			}
		case 3:
			divsr.ans4 = true
			switch divsr.sradap {
			case 0:
				divsr.su3 |= su3A | su3CLR
			case 1:
				divsr.su3 |= su3S
			case 2:
				divsr.su3 |= su3S | su3CLR
			}
		}

		// 根据数值清除标志 numcl 和分母清除标志 dencl 清除累加器状态
		if divsr.numcl[divsr.curprog] == 1 {
			accclear(2)
		}
		if divsr.dencl[divsr.curprog] == 1 {
			accclear(4)
		}

		// 清理内部状态
		divintclear()
		return
	}

	// qα 标志处理
	if divsr.qα {
		divsr.p1 = false
		divsr.m1 = false
		if overflow() { // Gates D9, D11, D12: 判断是否溢出
			doS() // 执行 S 操作
		} else {
			doP() // 执行 P 操作
		}
		divsr.qα = false
		divsr.su2 &^= su2qα // 清除状态单元 su2 中的 qα 标志
	} else if divsr.nγ { // Gates L10, G11, H11: nγ 标志处理
		divsr.nγ = false
		divsr.sv &^= svγ // 清除状态变量 sv 中的 γ 标志
		if divsr.divff {
			divsr.qα = true
			divsr.su2 |= su2qα // 设置状态单元 su2 中的 qα 标志
			if divsr.ds {
				divsr.ds = false
				divsr.su3 &^= su3S // 清除状态单元 su3 中的 ds 标志
				divsr.p1 = true
			} else if divsr.da {
				divsr.da = false
				divsr.su3 &^= su3A // 清除状态单元 su3 中的 da 标志
				divsr.m1 = true
			}
		} else {
			divsr.dγ = true
			divsr.su3 |= su3γ // 设置状态单元 su3 中的 dγ 标志
			if divsr.ds {
				divsr.ds = false
				divsr.su3 &^= su3S // 清除状态单元 su3 中的 ds 标志
				divsr.p2 = true
			} else if divsr.da {
				divsr.da = false
				divsr.su3 &^= su3A // 清除状态单元 su3 中的 da 标志
				divsr.m2 = true
			}
		}
	} else if divsr.npγ { // Gate C9: npγ 标志处理
		divsr.npγ = false
		divsr.sv &^= svγ // 清除状态变量 sv 中的 γ 标志
		divsr.sac = false
		divsr.su2 &^= su2sA | su2sCLR // 清除状态单元 su2 中的相关标志
		divsr.m1 = false
		divsr.p1 = false
		divsr.dpγ = false
		divsr.su3 &^= su3γ // 清除状态单元 su3 中的 γ 标志
		doP() // 执行 P 操作
	} else if divsr.sα { // Gates K7, L1: sα 标志处理
		divsr.sα = false
		divsr.su2 &^= su2sα // 清除状态单元 su2 中的 sα 标志
		divsr.nac = false
		divsr.sv &^= svA | svCLR // 清除状态变量 sv 中的相关标志
		divsr.sac = true
		divsr.su2 |= su2sA | su2sCLR // 设置状态单元 su2 中的相关标志
		divsr.npγ = true
		divsr.sv |= svγ // 设置状态变量 sv 中的 γ 标志
		divsr.numrplus, divsr.numrmin = divsr.numrmin, divsr.numrplus // 交换数值加减标志
	} else if divsr.dγ {
		divsr.dγ = false
		divsr.su3 &^= su3γ // 清除状态单元 su3 中的 γ 标志
		divsr.p2 = false
		divsr.m2 = false
		if overflow() {
			doS() // 执行 S 操作
		} else {
			doP() // 执行 P 操作
		}
	}

	// 处理程序环位置 progring 的不同状态
	switch divsr.progring {
	case 0:
		divsr.nα = false
		divsr.nβ = false
		divsr.sv &^= svα | svβ // 清除状态变量 sv 中的相关标志
		divsr.dα = false
		divsr.dβ = false
		divsr.su3 &^= su3α | su3β // 清除状态单元 su3 中的相关标志
		if !divsr.pringff {
			divsr.progring++
		}
	case 1: // Gate D6
		s := accstat(2)
		if s[0] == 'M' {
			divsr.numrplus, divsr.numrmin = divsr.numrmin, divsr.numrplus // 交换数值加减标志
		}
		s = accstat(4)
		if s[0] == 'M' {
			divsr.denomff = true
		}
		if !divsr.pringff {
			divsr.progring++
		}
	case 2: // Gate A7, B7, B8
		if divsr.divff {
			doP() // 执行 P 操作
			divsr.pringff = true
			divsr.progring = 0
		} else {
			divsr.p1 = true
			divsr.dγ = true
			divsr.su3 |= su3γ // 设置状态单元 su3 中的 γ 标志
			divsr.progring++
		}
	case 3:
		divsr.p1 = false
		divsr.dγ = false
		divsr.su3 &^= su3γ // 清除状态单元 su3 中的 γ 标志
		doP() // 执行 P 操作
		divsr.pringff = true
		divsr.progring = 0
	}
}

// 执行 IIIP 操作
func doIIIP() {
	// Gate C9: npγ 标志处理
	if divsr.npγ {
		divsr.npγ = false
		divsr.sv &^= svγ // 清除状态变量 sv 中的 γ 标志
		divsr.sac = false
		divsr.su2 &^= su2sA | su2sCLR // 清除状态单元 su2 中的相关标志
		divsr.m1 = false
		divsr.p1 = false
		divsr.dpγ = false
		divsr.su3 &^= su3γ // 清除状态单元 su3 中的 γ 标志
	} else if divsr.sα { // sα 标志处理
		divsr.sα = false
		divsr.su2 &^= su2sα // 清除状态单元 su2 中的 sα 标志
		divsr.nac = false
		divsr.sv &^= svA | svCLR // 清除状态变量 sv 中的相关标志
		divsr.sac = true
		divsr.su2 |= su2sA | su2sCLR // 设置状态单元 su2 中的相关标志
		divsr.npγ = true
		divsr.sv |= svγ // 设置状态变量 sv 中的 γ 标志
		if divsr.psrcff {
			divsr.dpγ = false
			divsr.su3 &^= su3γ // 清除状态单元 su3 中的 γ 标志
			divsr.m1 = false
			divsr.p1 = false
		}
		divsr.numrplus, divsr.numrmin = divsr.numrmin, divsr.numrplus // 交换数值加减标志
	} else if divsr.qα { // qα 标志处理
		divsr.qα = false
		divsr.su2 &^= su2qα // 清除状态单元 su2 中的 qα 标志
		divsr.m1 = false
		divsr.p1 = false
	} else if divsr.dγ { // dγ 标志处理
		divsr.dγ = false
		divsr.su3 &^= su3γ // 清除状态单元 su3 中的 γ 标志
		divsr.m2 = false
		divsr.p2 = false
	}

	// 处理程序环位置 progring 的不同状态
	switch divsr.progring {
	case 1:
		doP() // 执行 P 操作
	case 6: // Gate D4
		divsr.nγ = false
		divsr.sv &^= svγ // 清除状态变量 sv 中的 γ 标志
		divsr.da = false
		divsr.ds = false
		divsr.su3 &^= su3A | su3S // 清除状态单元 su3 中的相关标志
	case 7: // Gate J13
		if !overflow() && divsr.roundoff[divsr.curprog] == 1 { // Gate K12
			if divsr.divff {
				divsr.qα = true
				divsr.su2 |= su2qα // 设置状态单元 su2 中的 qα 标志
				if samesign() {
					divsr.p1 = true
				} else {
					divsr.m1 = true
				}
			} else {
				divsr.dγ = true
				divsr.su3 |= su3γ // 设置状态单元 su3 中的 γ 标志
				if samesign() {
					divsr.p2 = true
				} else {
					divsr.m2 = true
				}
			}
		}
	case 8: // Gate E3. L50
		divsr.psrcff = false
		divsr.coinff = true // 设置控制输入标志 coinff
	}

	divsr.progring++ // 增加程序环位置
}

// 分频器单元主循环
func divunit(cyctrunk chan pulse) {
	resp := make(chan int)
	divsr.divupdate = make(chan int)
	go divunit2() // 启动辅助协程
	divintclear() // 清理内部状态

	for {
		p := <-cyctrunk // 从脉冲通道接收脉冲

		switch {
		case p.val&Cpp != 0:
			// 如果当前是程序环的第一个位置，重置相关标志
			if divsr.progring == 0 {
				divsr.ans1 = false
				divsr.ans2 = false
				divsr.ans3 = false
				divsr.ans4 = false
				divsr.su2 &^= su2qA | su2qS | su2qCLR // 清除状态单元 su2 中的相关标志
				divsr.su3 &^= su3A | su3S | su3CLR // 清除状态单元 su3 中的相关标志
			}
			// 如果当前程序编号有效且没有源标志 psrcff，则执行 GP 操作；否则执行 IIIP 操作
			if divsr.curprog >= 0 {
				if divsr.psrcff == false { // Gate F4
					doGP(resp)
				} else { // Gate F5
					doIIIP()
				}
			}
		case p.val&Rp != 0:
			/*
			 * Ugly hack to avoid races
			 */
			// 遍历所有预设标志，设置相应的程序标志并更新当前程序编号
			for i := 0; i < 8; i++ {
				if divsr.preff[i] {
					divsr.preff[i] = false
					divsr.progff[i] = true
					divsr.curprog = i
				}
			}
		case p.val&Onep != 0 && divsr.p1 || p.val&Twop != 0 && divsr.p2:
			// 如果满足条件，则进行握手操作
			if divsr.placering < 9 {
				handshake(1<<uint(8-divsr.placering), divsr.answer, resp)
			}
		case p.val&Onep != 0 && divsr.m2 || p.val&Twopp != 0 && divsr.m1:
			handshake(0x7ff, divsr.answer, resp)
		case p.val&Onep != 0 && divsr.m1 || p.val&Twopp != 0 && divsr.m2:
			if divsr.placering < 9 {
				handshake(0x7ff^(1<<uint(8-divsr.placering)), divsr.answer, resp)
			} else {
				handshake(0x7ff, divsr.answer, resp)
			}
		case (p.val&Fourp != 0 || p.val&Twop != 0) && (divsr.m1 || divsr.m2):
			handshake(0x7ff, divsr.answer, resp)
		case p.val&Onepp != 0:
			if divsr.m1 || divsr.m2 {
				handshake(1, divsr.answer, resp)
			}
			if divsr.psrcff == false && divsr.sα { // Gate L45
				divsr.placering++
			}
		}

		// 如果脉冲包含响应通道，则发送响应
		if p.resp != nil {
			p.resp <- 1
		}
	}
}

// 辅助协程函数，处理来自不同程序输入通道的脉冲
func divunit2() {
	var p pulse // 定义一个脉冲变量

	for {
		p.resp = nil // 初始化响应通道为空

		select {
		case <-divsr.divupdate:
			// 处理 divupdate 通道的消息（当前没有具体操作）
		case p = <-divsr.progin[0]:
			divargs(0) // 根据接收到的脉冲调用 divargs 函数，并传递程序编号 0
		case p = <-divsr.progin[1]:
			divargs(1) // 根据接收到的脉冲调用 divargs 函数，并传递程序编号 1
		case p = <-divsr.progin[2]:
			divargs(2) // 根据接收到的脉冲调用 divargs 函数，并传递程序编号 2
		case p = <-divsr.progin[3]:
			divargs(3) // 根据接收到的脉冲调用 divargs 函数，并传递程序编号 3
		case p = <-divsr.progin[4]:
			divargs(4) // 根据接收到的脉冲调用 divargs 函数，并传递程序编号 4
		case p = <-divsr.progin[5]:
			divargs(5) // 根据接收到的脉冲调用 divargs 函数，并传递程序编号 5
		case p = <-divsr.progin[6]:
			divargs(6) // 根据接收到的脉冲调用 divargs 函数，并传递程序编号 6
		case p = <-divsr.progin[7]:
			divargs(7) // 根据接收到的脉冲调用 divargs 函数，并传递程序编号 7
		case p = <-divsr.ilock[0]:
			divsr.ilockff = true // 设置锁定标志 ilockff 为 true
		case p = <-divsr.ilock[1]:
			divsr.ilockff = true // 设置锁定标志 ilockff 为 true
		case p = <-divsr.ilock[2]:
			divsr.ilockff = true // 设置锁定标志 ilockff 为 true
		case p = <-divsr.ilock[3]:
			divsr.ilockff = true // 设置锁定标志 ilockff 为 true
		case p = <-divsr.ilock[4]:
			divsr.ilockff = true // 设置锁定标志 ilockff 为 true
		case p = <-divsr.ilock[5]:
			divsr.ilockff = true // 设置锁定标志 ilockff 为 true
		case p = <-divsr.ilock[6]:
			divsr.ilockff = true // 设置锁定标志 ilockff 为 true
		case p = <-divsr.ilock[7]:
			divsr.ilockff = true // 设置锁定标志 ilockff 为 true
		}

		// 如果脉冲包含响应通道，则发送响应
		if p.resp != nil {
			p.resp <- 1
		}
	}
}
